ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೆಂಪೊರಲ್ ಡ್ಯುರೇಶನ್‌ನಲ್ಲಿ ಪ್ರಾವೀಣ್ಯತೆ: ಸಮಯದ ಮಧ್ಯಂತರಗಳ ಲೆಕ್ಕಾಚಾರಗಳಿಗೆ ಒಂದು ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೆಂಪೊರಲ್ API ದಿನಾಂಕಗಳು ಮತ್ತು ಸಮಯಗಳನ್ನು ನಿರ್ವಹಿಸುವಲ್ಲಿ ಒಂದು ಮಹತ್ವದ ಪ್ರಗತಿಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಇದರ ಪ್ರಮುಖ ಘಟಕಗಳಲ್ಲಿ ಒಂದಾದ Duration ಆಬ್ಜೆಕ್ಟ್, ಸಮಯದ ಮಧ್ಯಂತರಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ವಿಶೇಷವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಬದಲಾಯಿಸಬಹುದಾದ ಮತ್ತು ಸಮಯವಲಯದ ಸಂಕೀರ್ಣತೆಗಳಿಂದ ಬಳಲುತ್ತಿರುವ ಸಾಂಪ್ರದಾಯಿಕ Date ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ಭಿನ್ನವಾಗಿ, Duration ಸಮಯದ ಅವಧಿಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಹೆಚ್ಚು ಸ್ವಚ್ಛ, ನಿಖರ ಮತ್ತು ಅಂತರರಾಷ್ಟ್ರೀಯ ಮಟ್ಟದಲ್ಲಿ ಅರಿವುಳ್ಳ ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತದೆ. ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯು Duration ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ವಿವರವಾಗಿ ಅನ್ವೇಷಿಸುತ್ತದೆ, ಮೂಲಭೂತ ಬಳಕೆಯಿಂದ ಸುಧಾರಿತ ಸನ್ನಿವೇಶಗಳವರೆಗೆ ಎಲ್ಲವನ್ನೂ ಒಳಗೊಂಡಿದೆ.

ಟೆಂಪೊರಲ್ ಡ್ಯುರೇಶನ್ ಎಂದರೇನು?

ಒಂದು Temporal.Duration ಸಮಯದ ಒಂದು ಅವಧಿಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಇದು ಯಾವುದೇ ನಿರ್ದಿಷ್ಟ ಕ್ಯಾಲೆಂಡರ್ ವ್ಯವಸ್ಥೆ ಅಥವಾ ಸಮಯ ವಲಯದಿಂದ ಸ್ವತಂತ್ರವಾಗಿದೆ. ಇದು ಕೇವಲ ಸಮಯದ ಪ್ರಮಾಣದ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ, ಇದನ್ನು ವರ್ಷಗಳು, ತಿಂಗಳುಗಳು, ದಿನಗಳು, ಗಂಟೆಗಳು, ನಿಮಿಷಗಳು, ಸೆಕೆಂಡುಗಳು ಮತ್ತು ಸೆಕೆಂಡಿನ ಭಿನ್ನರಾಶಿಗಳಲ್ಲಿ ವ್ಯಕ್ತಪಡಿಸಲಾಗುತ್ತದೆ. ಇದನ್ನು "5 ವರ್ಷಗಳು, 3 ತಿಂಗಳುಗಳು ಮತ್ತು 2 ದಿನಗಳು" ಎಂದು ಯೋಚಿಸಿ, "ಜನವರಿ 1, 2023 ರಿಂದ ಮಾರ್ಚ್ 3, 2028 ರವರೆಗೆ" ಎನ್ನುವುದಕ್ಕಿಂತ.

ಈ ವ್ಯತ್ಯಾಸವು ನಿರ್ಣಾಯಕವಾಗಿದೆ ಏಕೆಂದರೆ ಡ್ಯುರೇಶನ್‌ಗಳು ಅಂತರ್ಗತವಾಗಿ ಸಾಪೇಕ್ಷವಾಗಿರುತ್ತವೆ. ಒಂದು ನಿರ್ದಿಷ್ಟ ದಿನಾಂಕಕ್ಕೆ ಡ್ಯುರೇಶನ್ ಅನ್ನು ಸೇರಿಸಿದಾಗ ಯಾವಾಗಲೂ ಹೊಸ ದಿನಾಂಕ ದೊರೆಯುತ್ತದೆ, ಆದರೆ ನಿಖರವಾದ ಫಲಿತಾಂಶವು ಕ್ಯಾಲೆಂಡರ್ ವ್ಯವಸ್ಥೆ ಮತ್ತು ಪ್ರಾರಂಭದ ದಿನಾಂಕವನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಜನವರಿ 31ಕ್ಕೆ ಒಂದು ತಿಂಗಳನ್ನು ಸೇರಿಸಿದಾಗ, ಆ ವರ್ಷ ಅಧಿಕ ವರ್ಷವೇ ಎಂಬುದನ್ನು ಅವಲಂಬಿಸಿ ವಿಭಿನ್ನ ದಿನಾಂಕಗಳು ಫಲಿತಾಂಶವಾಗಿ ಬರುತ್ತವೆ.

ಡ್ಯುರೇಶನ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸುವುದು

Temporal.Duration ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸಲು ಹಲವಾರು ಮಾರ್ಗಗಳಿವೆ:

1. ಘಟಕಗಳಿಂದ (Components)

ಅಪೇಕ್ಷಿತ ಘಟಕಗಳನ್ನು ಹೊಂದಿರುವ ಆಬ್ಜೆಕ್ಟ್‌ನೊಂದಿಗೆ Temporal.Duration.from ಮೆಥೆಡ್ ಅನ್ನು ಬಳಸುವುದು ಅತ್ಯಂತ ನೇರವಾದ ಮಾರ್ಗವಾಗಿದೆ:

            const duration1 = Temporal.Duration.from({ years: 1, months: 6, days: 15 });
console.log(duration1.toString()); // Output: P1Y6M15D

const duration2 = Temporal.Duration.from({ hours: 8, minutes: 30, seconds: 12, milliseconds: 500 });
console.log(duration2.toString()); // Output: PT8H30M12.5S

const duration3 = Temporal.Duration.from({ years: 2, days: -5, seconds: 30 });
console.log(duration3.toString()); // Output: P2YT-5S30S

            

              
                Copy
              
            
          

ಸಮಯದಲ್ಲಿ ಹಿಂದಕ್ಕೆ ಚಲಿಸುವ ಡ್ಯುರೇಶನ್‌ಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ನೀವು ಋಣಾತ್ಮಕ ಮೌಲ್ಯಗಳನ್ನು ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ಗಮನಿಸಿ.

2. ISO 8601 ಸ್ಟ್ರಿಂಗ್‌ನಿಂದ

Temporal.Duration.from ಮೆಥೆಡ್ ISO 8601 ಡ್ಯುರೇಶನ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸಹ ಸ್ವೀಕರಿಸುತ್ತದೆ:

            const duration4 = Temporal.Duration.from('P3Y2M10DT5H30M');
console.log(duration4.toString()); // Output: P3Y2M10DT5H30M

const duration5 = Temporal.Duration.from('PT1H15M30S');
console.log(duration5.toString()); // Output: PT1H15M30S

const duration6 = Temporal.Duration.from('P-1Y');
console.log(duration6.toString()); // Output: P-1Y

            

              
                Copy
              
            
          

ISO 8601 ಡ್ಯುರೇಶನ್ ಫಾರ್ಮ್ಯಾಟ್ P[years]Y[months]M[days]D[T[hours]H[minutes]M[seconds]S] ಆಗಿದೆ. 'P' ಯು ಪೀರಿಯಡ್ (ಡ್ಯುರೇಶನ್) ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಮತ್ತು 'T' ದಿನಾಂಕ ಮತ್ತು ಸಮಯದ ಘಟಕಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸುತ್ತದೆ.

3. ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಬಳಸಿ

ನೀವು ನೇರವಾಗಿ Temporal.Duration ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಸಹ ಬಳಸಬಹುದು:

            const duration7 = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7, 8);
console.log(duration7.toString()); // Output: P1Y2M3W4DT5H6M7S8ms

            

              
                Copy
              
            
          

ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು ಈ ಕ್ರಮದಲ್ಲಿವೆ: years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds.

ಡ್ಯುರೇಶನ್ ಪ್ರಾಪರ್ಟಿಗಳು

ಒಮ್ಮೆ ನೀವು Duration ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹೊಂದಿದ್ದರೆ, ಅದರ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಅದರ ಘಟಕಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು:

            const duration = Temporal.Duration.from('P1Y2M3DT4H5M6S');

console.log(duration.years);       // Output: 1
console.log(duration.months);      // Output: 2
console.log(duration.days);        // Output: 3
console.log(duration.hours);       // Output: 4
console.log(duration.minutes);     // Output: 5
console.log(duration.seconds);     // Output: 6
console.log(duration.milliseconds);  // Output: 0
console.log(duration.microseconds);  // Output: 0
console.log(duration.nanoseconds);   // Output: 0

            

              
                Copy
              
            
          

ಡ್ಯುರೇಶನ್ ಅಂಕಗಣಿತ (Arithmetic)

Duration ಆಬ್ಜೆಕ್ಟ್ ಅಂಕಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಮೆಥೆಡ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ:

1. ಡ್ಯುರೇಶನ್‌ಗಳನ್ನು ಸೇರಿಸುವುದು

ಎರಡು ಡ್ಯುರೇಶನ್‌ಗಳನ್ನು ಒಟ್ಟಿಗೆ ಸೇರಿಸಲು add ಮೆಥೆಡ್ ಬಳಸಿ:

            const duration1 = Temporal.Duration.from('P1Y2M');
const duration2 = Temporal.Duration.from('P3M4D');

const sum = duration1.add(duration2);
console.log(sum.toString()); // Output: P1Y5M4D

            

              
                Copy
              
            
          

2. ಡ್ಯುರೇಶನ್‌ಗಳನ್ನು ಕಳೆಯುವುದು

ಒಂದು ಡ್ಯುರೇಶನ್‌ನಿಂದ ಇನ್ನೊಂದನ್ನು ಕಳೆಯಲು subtract ಮೆಥೆಡ್ ಬಳಸಿ:

            const duration1 = Temporal.Duration.from('P1Y2M');
const duration2 = Temporal.Duration.from('P3M4D');

const difference = duration1.subtract(duration2);
console.log(difference.toString()); // Output: PPT11M-4D

            

              
                Copy
              
            
          

3. ಡ್ಯುರೇಶನ್ ಅನ್ನು ನೆಗೆಟ್ ಮಾಡುವುದು

ಡ್ಯುರೇಶನ್‌ನಲ್ಲಿನ ಎಲ್ಲಾ ಘಟಕಗಳ ಚಿಹ್ನೆಯನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸಲು negated ಮೆಥೆಡ್ ಬಳಸಿ:

            const duration = Temporal.Duration.from('P1Y2M-3D');
const negatedDuration = duration.negated();
console.log(negatedDuration.toString()); // Output: P-1YT-2M3D

            

              
                Copy
              
            
          

4. ಡ್ಯುರೇಶನ್‌ನ ನಿರಪೇಕ್ಷ ಮೌಲ್ಯ (Absolute Value)

ಎಲ್ಲಾ ಧನಾತ್ಮಕ ಘಟಕಗಳೊಂದಿಗೆ ಡ್ಯುರೇಶನ್ ಪಡೆಯಲು abs ಮೆಥೆಡ್ ಬಳಸಿ:

            const duration = Temporal.Duration.from('P-1YT2M-3D');
const absoluteDuration = duration.abs();
console.log(absoluteDuration.toString()); // Output: P1YT2M3D

            

              
                Copy
              
            
          

5. ಡ್ಯುರೇಶನ್ ಅನ್ನು ಗುಣಿಸುವುದು

ಡ್ಯುರೇಶನ್ ಅನ್ನು ಒಂದು ಸಂಖ್ಯೆಯಿಂದ ಗುಣಿಸಲು multiply ಮೆಥೆಡ್ ಬಳಸಿ:

            const duration = Temporal.Duration.from('PT1H30M');
const multipliedDuration = duration.multiply(2.5);
console.log(multipliedDuration.toString()); // Output: PT3H45M

            

              
                Copy
              
            
          

6. ಡ್ಯುರೇಶನ್ ಅನ್ನು ರೌಂಡ್ ಮಾಡುವುದು

ಒಂದು ಡ್ಯುರೇಶನ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟ ಯೂನಿಟ್‌ಗೆ ರೌಂಡ್ ಮಾಡಲು round ಮೆಥೆಡ್ ಬಳಸಿ. ಇದಕ್ಕೆ relativeTo ಆಯ್ಕೆಯನ್ನು ಒದಗಿಸಬೇಕಾಗುತ್ತದೆ, ಅದು Temporal.PlainDateTime ಅಥವಾ Temporal.ZonedDateTime ಆಗಿರಬಹುದು, ಏಕೆಂದರೆ ಕೆಲವು ಯೂನಿಟ್‌ಗಳು (ತಿಂಗಳುಗಳು ಮತ್ತು ವರ್ಷಗಳಂತಹವು) ಬದಲಾಗುವ ಉದ್ದವನ್ನು ಹೊಂದಿರುತ್ತವೆ.

            const duration = Temporal.Duration.from('P1DT12H30M');
const relativeTo = Temporal.PlainDateTime.from('2024-01-01T00:00:00');

const roundedDuration = duration.round({ smallestUnit: 'days', relativeTo });
console.log(roundedDuration.toString()); // Output: P2D

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, 1 ದಿನ ಮತ್ತು 12 ಗಂಟೆಗಳನ್ನು 2 ದಿನಗಳಿಗೆ ರೌಂಡ್ ಮಾಡಲಾಗಿದೆ.

ಡ್ಯುರೇಶನ್‌ಗಳನ್ನು ಹೋಲಿಸುವುದು

ನೀವು ಎರಡು ಡ್ಯುರೇಶನ್‌ಗಳನ್ನು compare ಮೆಥೆಡ್ ಬಳಸಿ ಹೋಲಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಮಿಶ್ರ ಯೂನಿಟ್‌ಗಳನ್ನು (ಉದಾಹರಣೆಗೆ, ವರ್ಷಗಳು ಮತ್ತು ದಿನಗಳು) ಹೊಂದಿರುವ ಡ್ಯುರೇಶನ್‌ಗಳನ್ನು ಸಾಪೇಕ್ಷ ಸಂದರ್ಭವಿಲ್ಲದೆ (ಒಂದು ನಿರ್ದಿಷ್ಟ ದಿನಾಂಕ ಮತ್ತು ಕ್ಯಾಲೆಂಡರ್) ವಿಶ್ವಾಸಾರ್ಹವಾಗಿ ಹೋಲಿಸಲಾಗುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ. compare ಫಂಕ್ಷನ್ ಹಿಂತಿರುಗಿಸುತ್ತದೆ:

• duration1 duration2 ಗಿಂತ ಕಡಿಮೆಯಿದ್ದರೆ -1
• duration1 duration2 ಗೆ ಸಮನಾಗಿದ್ದರೆ 0
• duration1 duration2 ಗಿಂತ ಹೆಚ್ಚಾಗಿದ್ದರೆ 1

            const duration1 = Temporal.Duration.from('PT1H');
const duration2 = Temporal.Duration.from('PT30M');

console.log(Temporal.Duration.compare(duration1, duration2)); // Output: 1
console.log(Temporal.Duration.compare(duration2, duration1)); // Output: -1
console.log(Temporal.Duration.compare(duration1, Temporal.Duration.from('PT1H'))); // Output: 0

const duration3 = Temporal.Duration.from('P1M');
const duration4 = Temporal.Duration.from('P30D');

// Comparing duration3 and duration4 directly will throw an error in many engines
// unless 'relativeTo' is specified, as the length of a month is not constant.

            

              
                Copy
              
            
          

ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಬಳಕೆಯ ಸಂದರ್ಭಗಳು

Temporal.Duration ಆಬ್ಜೆಕ್ಟ್ ಅತ್ಯಂತ ಬಹುಮುಖವಾಗಿದೆ ಮತ್ತು ಇದನ್ನು ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಬಳಸಬಹುದು:

1. ಯೋಜನೆಯ ಅವಧಿಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು

ನೀವು ಪ್ರಾರಂಭ ದಿನಾಂಕ ಮತ್ತು ಅಂತಿಮ ದಿನಾಂಕವನ್ನು ಹೊಂದಿರುವ ಯೋಜನೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಯೋಜನೆಯ ಅವಧಿಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ನೀವು Temporal.PlainDate ಮತ್ತು Temporal.Duration ಅನ್ನು ಬಳಸಬಹುದು:

            const startDate = Temporal.PlainDate.from('2024-01-15');
const endDate = Temporal.PlainDate.from('2024-03-20');

const duration = endDate.since(startDate);
console.log(duration.toString()); // Output: P1M5D

            

              
                Copy
              
            
          

2. ಪುನರಾವರ್ತಿತ ಈವೆಂಟ್‌ಗಳನ್ನು ನಿಗದಿಪಡಿಸುವುದು

ವಾರದ ಸಭೆಗಳು ಅಥವಾ ಮಾಸಿಕ ವರದಿಗಳಂತಹ ಪುನರಾವರ್ತಿತ ಈವೆಂಟ್‌ಗಳ ಆವರ್ತನವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ನೀವು Temporal.Duration ಅನ್ನು ಬಳಸಬಹುದು:

            const eventFrequency = Temporal.Duration.from({ weeks: 1 });
let nextEventDate = Temporal.PlainDate.from('2024-01-22');

for (let i = 0; i < 5; i++) {
  console.log(`Event ${i + 1}: ${nextEventDate.toString()}`);
  nextEventDate = nextEventDate.add(eventFrequency);
}

// Output:
// Event 1: 2024-01-22
// Event 2: 2024-01-29
// Event 3: 2024-02-05
// Event 4: 2024-02-12
// Event 5: 2024-02-19

            

              
                Copy
              
            
          

3. ವಯಸ್ಸನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು

ವಯಸ್ಸನ್ನು ನಿಖರವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಅಧಿಕ ವರ್ಷಗಳು ಮತ್ತು ವಿಭಿನ್ನ ಕ್ಯಾಲೆಂಡರ್ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಅಗತ್ಯವಿದ್ದರೂ, Temporal.Duration ಉತ್ತಮ ಅಂದಾಜನ್ನು ಒದಗಿಸುತ್ತದೆ:

            const birthDate = Temporal.PlainDate.from('1990-05-10');
const today = Temporal.PlainDate.from('2024-02-15');

const ageDuration = today.since(birthDate);

console.log(`Approximate age: ${ageDuration.years} years, ${ageDuration.months} months, ${ageDuration.days} days`);

            

              
                Copy
              
            
          

4. ಸಮಯ ವಲಯ ಅರಿತ ಲೆಕ್ಕಾಚಾರಗಳು: ವಿಮಾನದ ಅವಧಿಗಳು

ಜಾಗತಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ, ಸಮಯ ವಲಯಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ನಿರ್ಣಾಯಕ. ವಿಭಿನ್ನ ಸಮಯ ವಲಯಗಳ ನಡುವಿನ ವಿಮಾನದ ಅವಧಿಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದನ್ನು ಪರಿಗಣಿಸಿ:

            const departureZonedDateTime = Temporal.ZonedDateTime.from('2024-03-15T10:00:00[America/Los_Angeles]');
const arrivalZonedDateTime = Temporal.ZonedDateTime.from('2024-03-16T14:30:00[Europe/London]');

const flightDuration = arrivalZonedDateTime.since(departureZonedDateTime);

console.log(`Flight Duration: ${flightDuration.hours} hours, ${flightDuration.minutes} minutes`);
console.log(flightDuration.toString());

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯು Temporal.ZonedDateTime, .since() ಜೊತೆ ಸೇರಿದಾಗ, ಸಮಯ ವಲಯದ ವ್ಯತ್ಯಾಸಗಳಿಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಹೊಂದಿಕೊಂಡು, ನಿಖರವಾದ ವಿಮಾನದ ಅವಧಿಯನ್ನು ಹೇಗೆ ಒದಗಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ.

5. ಸೇವಾ ಮಟ್ಟದ ಒಪ್ಪಂದಗಳನ್ನು (SLAs) ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದು

ಅನೇಕ ಆನ್‌ಲೈನ್ ಸೇವೆಗಳು ಅಪ್‌ಟೈಮ್ ಗ್ಯಾರಂಟಿಗಳನ್ನು ಭರವಸೆ ನೀಡುತ್ತವೆ. ಈ ಒಪ್ಪಂದಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಮತ್ತು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ನೀವು `Temporal.Duration` ಅನ್ನು ಬಳಸಬಹುದು.

            const slaGuarantee = Temporal.Duration.from('PT99H59M59S'); // Almost 100 hours
const downtime = Temporal.Duration.from('PT1H');

if (downtime.compare(slaGuarantee) > 0) {
  console.log("SLA breached!");
} else {
  console.log("SLA met.");
}

            

              
                Copy
              
            
          

ಸುಧಾರಿತ ಪರಿಗಣನೆಗಳು

1. ತಿಂಗಳುಗಳು ಮತ್ತು ವರ್ಷಗಳ ಅಸ್ಪಷ್ಟತೆ

ಹಿಂದೆ ಹೇಳಿದಂತೆ, ತಿಂಗಳುಗಳು ಮತ್ತು ವರ್ಷಗಳ ಉದ್ದವು ಬದಲಾಗಬಹುದು. ಈ ಯೂನಿಟ್‌ಗಳನ್ನು ಒಳಗೊಂಡ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಮಾಡುವಾಗ, Temporal.PlainDateTime ಅಥವಾ Temporal.ZonedDateTime ಬಳಸಿ ಸಾಪೇಕ್ಷ ಸಂದರ್ಭವನ್ನು ಒದಗಿಸುವುದು ಹೆಚ್ಚಾಗಿ ಅಗತ್ಯವಾಗಿರುತ್ತದೆ. ಡ್ಯುರೇಶನ್‌ಗಳನ್ನು ರೌಂಡ್ ಮಾಡುವಾಗ ಅಥವಾ ಹೋಲಿಸುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಮುಖ್ಯವಾಗಿದೆ.

2. ಕ್ಯಾಲೆಂಡರ್ ವ್ಯವಸ್ಥೆಗಳು

ಟೆಂಪೊರಲ್ API ವಿಭಿನ್ನ ಕ್ಯಾಲೆಂಡರ್ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ. ಡಿಫಾಲ್ಟ್ ಆಗಿ, ಇದು ISO 8601 ಕ್ಯಾಲೆಂಡರ್ ಅನ್ನು ಬಳಸುತ್ತದೆ, ಇದು ಅತ್ಯಂತ ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲ್ಪಡುತ್ತದೆ. ಆದಾಗ್ಯೂ, Temporal.PlainDate ಅಥವಾ Temporal.ZonedDateTime ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸುವಾಗ ನೀವು ಇತರ ಕ್ಯಾಲೆಂಡರ್ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು. ಡ್ಯುರೇಶನ್‌ಗಳು ಕ್ಯಾಲೆಂಡರ್-ಅಜ್ಞೇಯವಾಗಿ ಉಳಿಯುತ್ತವೆ; ಅವು ಸಮಯದ ಪ್ರಮಾಣವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ.

3. ಸಮಯ ವಲಯ ಡೇಟಾಬೇಸ್ ಅಪ್‌ಡೇಟ್‌ಗಳು

ರಾಜಕೀಯ ಅಥವಾ ಭೌಗೋಳಿಕ ಕಾರಣಗಳಿಂದಾಗಿ ಸಮಯ ವಲಯದ ನಿಯಮಗಳು ಕಾಲಾನಂತರದಲ್ಲಿ ಬದಲಾಗಬಹುದು. ನಿಖರವಾದ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಿಮ್ಮ ಸಮಯ ವಲಯ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಅಪ್‌-ಟು-ಡೇಟ್ ಆಗಿ ಇಟ್ಟುಕೊಳ್ಳುವುದು ನಿರ್ಣಾಯಕ, ವಿಶೇಷವಾಗಿ Temporal.ZonedDateTime ನೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ. ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ರನ್‌ಟೈಮ್‌ಗಳು ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರ್ವಹಿಸುತ್ತವೆ, ಆದರೆ ಕೆಲವು ಪರಿಸರಗಳಲ್ಲಿ, ನೀವು ಡೇಟಾಬೇಸ್ ಅನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಅಪ್‌ಡೇಟ್ ಮಾಡಬೇಕಾಗಬಹುದು.

ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

• ಸೀರಿಯಲೈಸೇಶನ್ ಮತ್ತು ಡೇಟಾ ವಿನಿಮಯಕ್ಕಾಗಿ ISO 8601 ಡ್ಯುರೇಶನ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಬಳಸಿ. ಇದು ಪರಸ್ಪರ ಕಾರ್ಯಸಾಧ್ಯತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ ಮತ್ತು ಅಸ್ಪಷ್ಟತೆಯನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.
• ಎರಡು Date ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ನೇರವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಬದಲು, ಸಮಯದ ಮಧ್ಯಂತರಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು Temporal.Duration ಅನ್ನು ಬಳಸಿ. ಇದು ಹೆಚ್ಚು ಸ್ವಚ್ಛ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್‌ಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
• ತಿಂಗಳುಗಳು ಮತ್ತು ವರ್ಷಗಳ ಅಸ್ಪಷ್ಟತೆಯ ಬಗ್ಗೆ ಗಮನವಿರಲಿ, ಮತ್ತು ಅಗತ್ಯವಿದ್ದಾಗ ಯಾವಾಗಲೂ ಸಾಪೇಕ್ಷ ಸಂದರ್ಭವನ್ನು ಒದಗಿಸಿ.
• ಸಮಯ ವಲಯ-ಅರಿತ ಲೆಕ್ಕಾಚಾರಗಳಿಗಾಗಿ Temporal.ZonedDateTime ಬಳಸಿ.
• ನಿಮ್ಮ ಸಮಯ ವಲಯ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಅಪ್‌-ಟು-ಡೇಟ್ ಆಗಿ ಇರಿಸಿ.
• ಮಿಶ್ರ ಯೂನಿಟ್‌ಗಳೊಂದಿಗೆ ಡ್ಯುರೇಶನ್‌ಗಳನ್ನು ಹೋಲಿಸುವಾಗ, ನಿಖರವಾದ ಹೋಲಿಕೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಯಾವಾಗಲೂ ಸಾಪೇಕ್ಷ ಸಂದರ್ಭದೊಂದಿಗೆ round ಬಳಸಿ.

ತೀರ್ಮಾನ

Temporal.Duration ಆಬ್ಜೆಕ್ಟ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸಮಯದ ಮಧ್ಯಂತರಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಒಂದು ಶಕ್ತಿಯುತ ಮತ್ತು ಸುಲಭವಾದ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಅದರ ಪ್ರಾಪರ್ಟಿಗಳು, ಮೆಥೆಡ್‌ಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಹೆಚ್ಚು ದೃಢವಾದ, ನಿಖರವಾದ ಮತ್ತು ಅಂತರರಾಷ್ಟ್ರೀಯ ಮಟ್ಟದಲ್ಲಿ ಅರಿವುಳ್ಳ ಕೋಡ್ ಅನ್ನು ಬರೆಯಬಹುದು. ಟೆಂಪೊರಲ್ API, ಮತ್ತು ನಿರ್ದಿಷ್ಟವಾಗಿ Duration ಆಬ್ಜೆಕ್ಟ್, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ದಿನಾಂಕ ಮತ್ತು ಸಮಯ ನಿರ್ವಹಣೆಯಲ್ಲಿ ಒಂದು ಮಹತ್ವದ ಹೆಜ್ಜೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಇದು ನಿಖರ ಮತ್ತು ಜಾಗತಿಕವಾಗಿ ಪ್ರಸ್ತುತವಾಗಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವುದನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ. ಟೆಂಪೊರಲ್ API ಅನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ ಮತ್ತು ನಿಮ್ಮ ಸಮಯ-ಸಂಬಂಧಿತ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಸರಳಗೊಳಿಸಲು ಅದರ ಸಾಮರ್ಥ್ಯವನ್ನು ಅನ್ಲಾಕ್ ಮಾಡಿ.

ಟೆಂಪೊರಲ್ API ವಿಕಸನಗೊಳ್ಳುತ್ತಾ ಸಾಗಿದಂತೆ, ಹೊಸ ವೈಶಿಷ್ಟ್ಯಗಳು ಮತ್ತು ಅಪ್‌ಡೇಟ್‌ಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿ ಪಡೆದುಕೊಳ್ಳಿ. ಅಧಿಕೃತ ECMAScript ಪ್ರಸ್ತಾಪ ಮತ್ತು ಸಂಬಂಧಿತ ದಾಖಲಾತಿಗಳು ಪ್ರಸ್ತುತವಾಗಿರಲು ಅತ್ಯುತ್ತಮ ಸಂಪನ್ಮೂಲಗಳಾಗಿವೆ.